package com.example.servicelogin.services.impl;

import com.example.servicelogin.mapper.UserMapper;
import com.example.login.po.UserEasy;
import com.example.servicelogin.services.Testservice;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.concurrent.TimeUnit;


@Service
public class TestserciceImpl implements Testservice {
    public static final Integer USER_INFO_TIMEOUT = 60 * 60 * 24;
    @Autowired
    UserMapper userMapper;
    @Autowired
    private RedisTemplate redisTemplate;

//    @Cacheable(value = "UserEasy",key = "'netty:sql:UserEasy'")
    @Override
    public List<UserEasy> queryAll() {
        // 尝试从 Redis 中获取缓存的数据
        List<UserEasy> cachedResult = (List<UserEasy>)
                redisTemplate.opsForValue().get("netty:sql:UserEasy");
        if (cachedResult != null && !cachedResult.isEmpty()) {
            return cachedResult; // 如果缓存存在且不为空，直接返回缓存数据
        }

        // 如果缓存不存在或为空，则调用数据库查询
        List<UserEasy> result = userMapper.queryAll();

        // 将结果存入 Redis 缓存，设置过期时间（例如：1小时）
        redisTemplate.opsForValue().set("netty:sql:UserEasy", result,USER_INFO_TIMEOUT, TimeUnit.SECONDS);
//        redisTemplate.expire("netty:sql:UserEasy", 1, TimeUnit.HOURS);

        return result;
    }
    //   查缓存 如果存在不执行sql
//    @Cacheable(value = "UserEasy",key = "'netty:sql:user:User' + #userId")
    @Override
    public UserEasy queryByUserId(String userId) {
        String cacheKey = "netty:sql:user:User" + userId;

        // 尝试从 Redis 中获取缓存的数据
        UserEasy cachedUser = (UserEasy) redisTemplate.opsForValue().get(cacheKey);
        if (cachedUser != null) {
            return cachedUser; // 如果缓存存在，直接返回缓存数据
        }

        // 如果缓存不存在，则调用数据库查询
        UserEasy user = userMapper.queryByUserId(userId);
        if (user != null) {
            // 将结果存入 Redis 缓存，设置过期时间（例如：30分钟）
            redisTemplate.opsForValue().set(cacheKey, user,USER_INFO_TIMEOUT);
        }

//        redisTemplate.expire(cacheKey, 30, TimeUnit.MINUTES);

        return user;
    }


    // TODO 先修改数据库 在修改缓存 （存在双写一致性问题）
//    @CachePut(value = "UserEasy",key = "'netty:sql:user:User' + #userEasy.userId")
    @Override
    public int insert(UserEasy userEasy) {
        int affectedRows = userMapper.insert(userEasy);
        if (affectedRows != 1) {
            return 0;
        }
        // =========== 手动更新缓存 ===========
        String cacheKey = "netty:sql:user:User:" + userEasy.getUserId(); // 定义缓存键，例如 "user:123"
        redisTemplate.opsForValue().set(cacheKey, userEasy,USER_INFO_TIMEOUT); // 将用户对象存入缓存
        // 如果需要设置过期时间，可以使用如下代码：
        // redisTemplate.expire(cacheKey, 3600, TimeUnit.SECONDS); // TTL 设置为 1 小时
        // ==================================

        return 1;
    }
    // TODO 先修改数据库 在修改缓存 （存在双写一致性问题）
//    @CachePut(value = "UserEasy",key = "'netty:sql:user:User' + #userEasy.userId")
    @Override
    public int update(UserEasy userEasy) {
        int result = userMapper.update(userEasy); // 执行数据库更新

        if (result > 0) { // 如果更新成功，则刷新缓存
            String cacheKey = "netty:sql:user:User" + userEasy.getUserId(); // 构建缓存键
            redisTemplate.opsForValue().set(cacheKey, userEasy,USER_INFO_TIMEOUT); // 将最新的用户数据写入缓存
            // 可选：设置过期时间（根据业务需求）
            // redisTemplate.expire(cacheKey, 3600, TimeUnit.SECONDS); // TTL 设置为 1 小时
        }

        return result; // 返回受影响的行数
    }

    @CacheEvict(value = "UserEasy",key = "'netty:sql:user:User' + #id")
    @Override
    public int delete(int i) {
        return userMapper.delete(i);
    }
}
